
# random.randint(n, m)   # 获取n-m之间的一个随机数

# import random

# name = 'caimiaoge'  # 定义 赋值一个变量
# print(name)  # 输出变量：caimiaoge
# print(type(name))  # 输出变量类型：<class 'str'>

# --------------------------python3.0版本以上运行 _ 符合作为数字的分隔符
# id = 123_456_789
# print(id)  # 输出结果为：123456789

# -----------------------字符串需要使用 双引号（" "） 或者 单引号（' '） 或者 三引号（""" 允许换行 """）括起来
# name1 = '菜猫猫'
# name2 = "猫猫菜"
# name3 = """"mao"""  # 允许换行
# print(name1)  # 输出结果：菜猫猫
# print(name2)  # 输出结果：猫猫菜
# print(name3)  # 输出结果：猫猫菜

# ------------------------数据类型转换
# str1 = '123hhh'
# print(int(str1))  # 会报错，字符串转换为整数型时，必须全是数字才能转换
# str1 = "264264"
# print(type(str1))  # 输出结果：<class 'str'>

# ------------------------字符串转换为整数
# str1 = int(str1)
# print(type(str1))  # 输出结果：<class 'int'>

# -------------------------转换为字符串
# str1 = str(str1)
# print(type(str1))  # 输出结果：<class 'str'>

# -------------------------算术运算符
# num = 9
# num1 = num // 2  # 取整
# num2 = num % 2  # 取余
# print('num1 = ', num1, 'num2 = ', num2)

# ----------------------------赋值运算符
# num = 1
# num += 1  # num = num + 1，其余运算符类似

# # ----------------------------转义字符
# print('\'你好，我是猫猫！\'')  # 单引号转义，输出结果：'你好，我是猫猫！'
# print("\"你好，我是菜菜！\"")  # 双引号转义，输出结果："你好，我是菜菜！"
# # print('\'\t hello\t\'')  # tab键转义，输出结果：'	 hello	'

# # -------------------------占位符
# str1 = '猫猫'
# print('哈喽你好！%s同学' % str1)  # 字符串占位符演示
# num1 = 160
# num2 = 95
# print('身高：%d cm' % num1, '体重：%s kg' % num2)  # 数字占位符演示，也可以使用字符串占位置来替数字占位
# score = 98.99
# print('我的分数是：%f' % score)  # 浮点数占位符演示
# msg = '名字：%s，身高：%d cm，体重：%d kg，分数：%f' % (str1, num1, num2, score)  # 变量种使用占位符演示
# print('msg = ', msg)
# print('名字：%s，身高：%d cm，体重：%d kg，分数：%f' % (str1, num1, num2, score))  # 多个占位符演示

# -----------------------表达式占位
# name = 'maomao'
# print(f"你好！{name}")  # 使用表达式进行占位
# print(f"你好！{264 * 2}")  # 264*2 可以得到一个明确的结果 可以进行占位
# print(f"你好！{type(name)}")  # type(name)可以得到一个明确的结果 可以进行占位

# ----------------------------精度控制
# num1 = 123456789
# num2 = 98.99555
# print("num1 = %5d, num2 = %8.2f" % (num1, num2))  # 小数点的精度控制会四舍五入


# -----------------------------占位符练习
# name = '猫猫公司'    # 公司名称
# stock_price = 19.99    # 当前股价
# stock_code = 264994    # 股票代码
# stock_price_daily_growth_factor = 1.2   # 每日增长系数
# growth_days = 7   # 增长天数
# print(f"公司名称：{name},股票代码：{stock_code},当前股价：{stock_price}")
# print("每日增长系数：%0.1f,经过%d天的增长后，股价达到了：%0.2f" % (stock_price_daily_growth_factor,growth_days,growth_days*stock_price*stock_price))

# --------------------input语句：接收键盘输入的内容，print语句：输出语句
# name = input()   # 接收用户输入内容
# vip_type = type(name)
# print(f"您好！{name},您是尊贵的：{vip_type}用户")


# ------------------------if elif else 条件判断语句 练习
# print("欢迎来到猫猫儿童游乐园，儿童免费，学生半价（5元），成人收费（10元）！")
# age = input("请输入你的年龄：")
# age = int(age)
# if age <= 12:
#     print("您是儿童，免费游玩噢！ \n祝您游玩愉快")
# elif age > 12 & age <= 18:
#     print("您是学生，游玩需补票5元！ \n祝您游玩愉快")
# else:
#     print("您已成年，游玩需补票10元噢！ \n祝您游玩愉快！")

# --------------------------判断语句嵌套使用练习
# num = 7
# input_num = int(input("请猜一猜我心里想的数字是几："))
# if input_num != num:
#     if input_num > num:
#         # input_num = int(input("猜的太大啦！重新猜一次："))
#         print("猜的太大了")
#     else:
#         print("猜的太小了")
#     input_num = int(input("重新猜一猜："))
#     if input_num == num:
#         print("恭喜，第二次机会猜中啦！")
#     else:
#         if input_num > num:
#             # input_num = int(input("猜的太大啦！重新猜一次："))
#             print("猜的太大了")
#         else:
#             print("猜的太小了")
#     input_num = int(input("最后再猜一猜："))
#     if input_num == num:
#         print("恭喜，第三次机会猜中啦！")
#     else:
#         print("很遗憾错了啦！")
# else:
#     print("恭喜，第一次就猜对啦！")

# ------------------------while 循环 输出九九乘法口诀
# i = 1
# while i <= 9:
#     j = 1
#     while j <= i:
#         print(f"{j}*{i}={i * j}\t",end='')
#         if j == i:
#             print("\n")
#         j += 1
#     i += 1

# ----------------------for 循环练习，计算序列中包含多少个a
# name = "itheima is a brand of itcast"
# count = 0
# for x in name:
#     if x == 'a':
#         count += 1
# print(f"序列中包含{count}个a")

# ----------------------------range语句运用
# for x in range(0,7):    # 获取从0开始到7（不包含）结束之间的数字序列：0123456
#     print(x,end=',')
# print(" ")
# for x in range(8):     # 获取从0开始到8（不包含）结束之间的数字序列：01234567
#     print(x,end=',')
# print(" ")
# for x in range(0,10,2):  # 获取从0开始到10（不包含）结束之间间隔2位的数字序列：0123456
#     print(x,end=',')

# -------------------for 循环 输出九九乘法口诀
# for i in range(1,10):
#     for j in range(1,i+1):
#         print(f"{j}*{i}={i*j}\t",end='')
#         if j == i:
#             print("")
#         j += 1
#     i += 1

# ------------------------------循环中断练习
# money = 10000
# salary = 1000
# for i in range(1,21):
#     j = random.randint(1, 10)   # 获取1-10之间的一个随机数
#     if money == 0:
#         print("工资发完了，下个月在领取")
#         break
#     elif j < 5:
#         print(f"员工{i},绩效分{j}，低于5，补不发工资，下一位。")
#         continue
#     else:
#         money -= salary
#         print(f"向员工{i}发放工资{salary}元,绩效分{j},账户余额剩余{money}")

# ----------------------函数使用
# def helle():
#     print("你哈！欢迎加入猫猫乐园")
#
# n = helle()  # 函数没有返回值 默认返回None
# print(n, type(n))
#
# def add_num(x, y):
#     """
#     这里是函数说明文档，计算两个数字的和
#     :param x: x是传参
#     :param y: y是参数
#     :return: 返回x+y的值
#     """
#     return x + y
#
# sum1 = add_num(5, 6)
# print(sum)
#
# num = 500  # 这里的num是全局变量
# def fun1():
#     # num = 200;    # num在函数里面是局部变量，不会影响全局变量
#     # print(f"局部变量{num}")
#     global num  # 定义为全局变量，就可以影响外部的全局变量值
#     num = 1000
#     print(f"全局变量{num}")
#
# fun1()

# ---------------------------------atm机 函数练习
# money = 5000000  # 银行卡余额
# name = None  # 用户姓名
#
# def meau():
#     print("-----------主菜单------------")
#     print(f"{name},您好,欢迎来到猫猫银行ATM机，请选择您要执行的操作：")
#     print("查询余额\t请输入[1]")
#     print("存款\t\t请输入[2]")
#     print("取款\t\t请输入[3]")
#     print("退出\t\t请输入[4]")
#     change = input("请输入您的选择：")
#     return change
#
# def query():  # 查询余额函数
#     print("-----------查询余额-----------")
#     print(f"{name},您好,您的余额剩余：{money}")

# def deposit():  # 存款函数
#     global money
#     print("------------存款------------")
#     deposit_money = int(input("请输入您的存款金额："))
#     print(f"{name},您好,您存款{deposit_money}元成功")
#     money += deposit_money
#     print(f"{name},您好,您的余额剩余：{money}元")
#
# def draw():  # 取款函数
#     global money     # 定义全局变量
#     print("------------取款------------")
#     draw_money = int(input("请输入您的取款金额："))
#     print(f"{name},您好,您取款{draw_money}元成功")
#     money -= draw_money
#     print(f"{name},您好,您的余额剩余：{money}元")
#
# name = input("请输入您的姓名：")
# exit = False
# while not exit:
#     change = int(meau())
#     if change == 4:
#         print("退出成功！欢迎下次再来")
#         break
#     elif change == 1:
#         query()
#         continue
#     elif change == 2:
#         deposit()
#         continue
#     elif change == 3:
#         draw()
#         continue
#     else:
#         print("输入错误，请输入有效数字（1-4），请重新输入！")

# # -------------------------列表使用
# list_name = [[1, 2], '猫猫', 1999, ('元组', 1999,), {1, 2, 3}, {'name': '猫猫'}]
# print(list_name)
# # -------------------------查询某个元素在列表中的下标位置
# # index
# print(f"[’猫猫‘]元素的下标位置是：{list_name.index('猫猫')}")
#
# # -------------------------修改列表中某个下标的元素值
# list_name[2] = 19990801
# print(f'修改后的第3个元素值为：{list_name[2]}')
# # -------------------------插入元素
# # insert
# list_name.insert(0, '女孩')   # 列表任意位置插入元素,新增一个元素，如果该下标有元素，旧元素先后移动一个元素
# print(f'向下标0插入一位元素后的列表数据为：{list_name}')
# # append
# list_name.append(['本科', '软件工程'])   # 列表末尾插入整个元素，如果这个元素是一个字符串/列表/元组/集合/字典，是整个元素作为一个整体插入
# print(f'列表末尾插入整个元素后的数据为：{list_name}')
# # extend
# list_name.extend('abc')   # 列表末尾插入拆分元素，如果这个元素是一个字符串/列表/元组/集合/字典，是将元素拆分单个单个元素插入
# print(f'列表末尾插入拆分元素后的数据为：{list_name}')
# # -------------------------删除元素
# # del
# del list_name[1]   # 删除指定下标的元素
# print(f'删除第[1]个元素后的数据为：{list_name}')
# # pop
# pop_value = list_name.pop(3)  # 删除指定下标的元素，该元素可以作为返回值
# print(f'删除的元素内容为：{pop_value}，删除第[3]个元素后的数据为：{list_name}')
# # remove
# list_name.remove({1, 2, 3})   # 删除指定元素
# print(f'删除元素指定元素后的数据为：{list_name}')
# # -------------------------清空列表
# # clear
# list_name.clear()
# print(f'清空后的列表是一个空列表：{list_name}')
# --------------------列表循环 遍历
# -----------while 循环
# my_list = ['名字叫猫猫','家住翻斗乐园','不爱吃香菜不爱吃葱']
# def list_while_fun():
#     global my_list
#     index = 0
#     while index<len(my_list):    #  while循环是通过条件（下标）来遍历得到列表的元素
#         print(f"while循环列表里面有：{my_list[index]}")
#         index += 1
# # -------------for 循环
# def list_for_fun():
#     global my_list
#     for element in my_list:     #  for循环可以直接遍历列表中的元素
#         print(f"for循环列表里面有：{element}")
#
# list_while_fun()    # 使用while循环遍历列表
# list_for_fun()    # 使用for循环遍历列表

# ------------列表综合练习
# num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# def num_while_fun():
#     index = 0
#     new_list = []
#     while index < len(num_list):
#         if num_list[index] % 2 == 0:
#             new_list.append(num_list[index])
#         index += 1
#     return new_list
#
# def num_for_fun():
#     new_list = []
#     for ele in num_list:
#         if ele % 2 == 0:
#             new_list.append(ele)
#     return new_list
#
# while_list = num_while_fun()
# print(f"通过while循环，从列表：{num_list}中取出偶数，组成新列表：{while_list}")
# for_list = num_for_fun()
# print(f"通过for循环，从列表：{num_list}中取出偶数，组成新列表：{for_list}")

# ---------------元组
# t1 = ()    # 定义一个空元组
# print(f"{t1}",type(t1))
# t2 = ("猫猫",)     # 定义单个元素的元组,逗号结尾
# print(f"{t2}",type(t2))
# t3 = ("maomao")    # 若不是逗号结尾，则为字符串
# print(f"{t3}",type(t3))
# t4 = (1, "猫哥", [2, 6, 4],"猫哥")   # 元素类型不限制
# print(f"{t4}",type(t4))
# print(f"猫哥在元组中的位置是：{t4.index('猫哥')}")
# print(f"猫哥在元组中的个数是：{t4.count('猫哥')}")
# print(f"t4元组的长度是：{len(t4)}")
# def t_while_fun():
#     index = 0
#     while index < len(t4):
#         print(t4[index],end=',')
#         index += 1
#
# def t_for_fun():
#     for ele in t4:
#         print(ele,end=',')
#
# t_while_fun()
# t_for_fun()

# tuple_name = (1999, '猫猫', ['蔬菜', '水果'], {'集合1', '集合2'}, {'name': '猫猫'}, 1999)
# print(tuple_name)
# # -----------------------查询某个元素的下标位置
# # index
# print(f'("猫猫")元素的下标位置为：{tuple_name.index("猫猫")}')
# # ----------------------仅支持修改嵌套的列表和字典（可以操作增删改），其余元素不支持修改
# tuple_name[2][0] = '草莓'     # 修改列表
# tuple_name[4]['name'] = 'maomao'    # 修改字典
# print(f'修改元组中的列表和字典数据：{tuple_name}')
# # ----------------------元组的列表元素中新增元素
# tuple_name[2].append("车厘子")
# print(f'元组内的列表新增一个元素后的元组数据为：{tuple_name}')
# # ----------------------元组的列表元素中删除元素
# tuple_name[2].pop(1)
# print(f'元组内的列表删除一个元素后的元组数据为：{tuple_name}')
# # ---------------------统计元组内的某个元素个数
# print(f'元组内的[1999]元素的个数有：{tuple_name.count(1999)}个')
# # ---------------------统计元组的长度
# print(f'元组的长度为：{len(tuple_name)}')

# ---------------元组综合练习
# t5 = ('猫猫', 18, ['eat', 'music'])
# print(f"年龄在元组中的位置是：{t5.index(18)}")
# print(f"学生姓名是：{t5[0]}")
# del t5[2][0]       # 删除元组中嵌套的列表元素
# print(f"删除学生爱好中的eat：{t5}")
# t5[2].append('cooking')    # 增加元组中嵌套的列表元素
# print(f"增加爱好cooking：{t5}")

# --------------字符串
# str1 = '   my name is maomao how old are you    '
# str2 = ',my,name,is,maomao,how,old,are,you,'
# print(f"maomao在字符串中起始下标是：{str1.index('maomao')}")
# str3 = str1.replace('how old are you','nice to meet you')    # 将str1字符串中的某个字符串换成另一个 得到新的字符串
# print(f"将 {str1} 换成 {str3}")
# str4 = str1.split(' ')     # 根据空格进行分割，得到一个新的列表
# print(f"根据空格进行分割：{str4}")
# str5 = str1.split('maomao')     # 根据'maomao'进行分割，得到一个新的列表
# print(f"根据‘maomao’进行分割：{str5}")
# print(f"去除字符串前后空格：{str1.strip()}")     # 去除字符串前后空格
# print(f"去除字符串前后','：{str2.strip(',')}")    # 去除字符串前后','
# print(f"str1中m出现的次数是：{str1.count('m')}")    # 统计某个字符串出现的次数
# print(f"str1的长度是：{len(str1)}")    # 统计字符串长度


str1 = ' hello,my name is maomao,how old are you? '
print(f'字符串内容为：{str1}')
# ----------------------查询某个元素的下标值
# index
print(f'字符串[‘maomao’]元素所在的下标值是：{str1.index("maomao")}')
# ----------------------修改某个元素的



# ---------------字符串练习
# str1 = 'itheima itcast boxuegu'
# print(f'{str1}字符串中有多少个’it’：{str1.count("it")}个')
# str2 = str1.replace(" ","|")    # 将字符串中的空格替换成|，得到新的字符串
# print(f'将字符串1:{str1}中的空格替换成‘|’,输出结果字符串2：{str2}')
# print(print(f"将字符串2按照‘|’进行分割，得到结果：{str2.split('|')}"))  #将字符串按照|进行分割，得到新的列表

# ---------------序列（列表、元组、字符串）切片练习
# list1 = [0,1,2,3,4,5]
# result = list1[1:4:]    # 对列表进行切片，从下标1开始，到下标4结束，步长为1（可以省略）
# print(f"列表切片结果[1:4:]：{result}")   # 输出结果：[1,2,3]
#
# tuple1 = ('cai','mao','ge','maomao')
# result = tuple1[:]    # 对元组进行切片，从头开始，到结尾结束，步长为1，三个值均可以省略，可以只写一个：
# print(f"元组切片结果[::]：{result}")   # 输出结果：('cai','mao','ge','maomao')
#
# str1 = 'hello my name is maomao'
# result = str1[::2]    # 对字符串进行切片，从头到尾，步长为2
# print(f"字符串切片结果[::2]：{result}")   # 输出结果：('hlom aei amo')

# -----------------序列切片练习
# list2 = [264,994,801,830,264,994]
# print(f"1、将{list2}从头到尾步长为1进行切片")
# print(f"\t写法1--list2[::]： {list2[::]}")
# print(f"\t写法2--list2[:]： {list2[:]}")
# print(f"\t写法3--list2[::1]： {list2[::1]}")
#
# print(f"2、将{list2}从头到尾步长为n进行切片")    # 步长为n，则每次跳过n-1个元素取
# print(f"\t步长为1--list2[::1]： {list2[::1]}")
# print(f"\t步长为2--list2[::2]： {list2[::2]}")
# print(f"\t步长为3--list2[::3]： {list2[::3]}")
#
# print(f"3、将{list2}从n到n长为n进行切片")   # 结束为n则不包含n的值，省略则包含结尾
# print(f"\t从2-5，步长2--list2[2:5:2]： {list2[2:5:2]}")
# print(f"\t从1-4，步长3--list2[1:4:3]： {list2[1:4:3]}")
#
# print(f"3、将{list2}从n到n长为n进行倒序切片")     # 倒序取值
# print(f"\t从5-2，步长-1--list2[5:2:-1]： {list2[5:2:-1]}")
# print(f"\t从4-1，步长-3--list2[4:1:-3]： {list2[4:1:-3]}")

# ------------序列小练习
# str1 = '101园乐斗翻住家，oamoam叫我，好你'
# result = str1[::-1]      #  切片倒序得到完整字符串
# print(result)
# name = result[5:11:1]     # 切片得到名字
# print(name)
#
# result = str1.split('，')   # 分割字符串得到列表
# print(result)
# name = result[1].replace("叫我",'')    # 将列表的元素替换
# print(name)
# print(name[::-1])     # 倒序

# ----------------集合
# set1 = {'猫猫同学','身高160cm','体重46kg','不爱吃葱不爱吃香菜','猫猫同学','身高160cm'}    # 定义一个集合
# empty_set1 = set()    # 定义一个空集合
# print(f'set1集合中的内容是：{set1},类型是：{type(set1)}')   # 集合会去重，一个元素只出现一次
# set1.add('猫猫快跑')    # 使用 add 方法在集合里面添加一个新元素，位置随机
# print(f'在set1集合中添加一个新元素：{set1}')
# set1.remove('猫猫同学')  # 使用 remove 方法移除集合中的指定元素
# print(f'在set1集合中移除指定一个新元素：{set1}')
# pop_value = set1.pop()   # 随机取出集合中的一个元素
# print(f'在set1集合中随机取出一个元素：{pop_value}')
# set1.clear()  # 清空集合中的内容
# print(f'清空set1集合中的元素：{set1}')
#
# set2 = {'猫猫同学','身高160cm','体重46kg','不爱吃葱不爱吃香菜','身高160cm'}
# set3 = {'猫猫同学','拼音是maomao','家住翻斗花园'}
# set_difference = set2.difference(set3)   # 取集合1中与集合2不相同的元素，返回新的集合，原集合均不改变
# print(f'取set2中，set3没有的元素（得到新集合）：{set_difference}')
# print(f'原集合1：{set2}')
# print(f'原集合2：{set3}')
#
# set2.difference_update(set3)  # 删除集合1中与集合而相同的元素，改变集合1
# print(f'删除set2中与set3中相同的元素：{set2}')
#
# set4 = {'猫猫同学','身高160cm','体重46kg','不爱吃葱不爱吃香菜','身高160cm'}
# set5 = {'猫猫同学','拼音是maomao','家住翻斗花园'}
# set_union = set4.union(set5)    # 取两个集合的合集，去重，得到新集合
# print(f'返回set4和set5合集（去重）：{set_union},集合内有：{len(set_union)}元素')
#
# # -----------for循环遍历集合中的元素
# for ele in set_union:
#     print(f'set_union集合中有：{ele}元素')
#
# # --------------集合综合练习
# list1 = ['maomao','猫猫','去哪','随便','都行','猫猫','花园']
# set1 = set()
# for ele in list1:    # 将列表中的元素通过for循环依次加入集合中
#     set1.add(ele)
# print(set1)
#
# set2 = set()
# i = 0
# while i < len(list1):    # 将列表中的元素通过while循环依次加入集合中
#     set2.add(list1[i])
#     i += 1
# print(set2)

# ----------------字典
# empty_dict1 = {}    # 定义空字典
# empty_dict2 = dict()   # 定义空字典
#
# dict1 = {'猫猫':'99','芬子宝':'100','影子宝':'99','宝子':'98'}   # 定义一个字典，键值对，键：值
# print(f'查询猫猫同学的分数：{dict1["猫猫"]}')    # 通过dict[key]返回key对应的value
# print(f'查询芬子宝同学的分数：{dict1["芬子宝"]}')
# print(f'查询影子宝同学的分数：{dict1["影子宝"]}')
# print(f'查询宝子同学的分数：{dict1["宝子"]}')
#
# dict2 = {    # key除了不能为字典，其他数据类型都可以，value可以是任意数据类型，value可以嵌套字典，列表、元组、等
#     '猫猫':{'数学':'95','英语':'88','语文':'96'},
#     '芬子宝':{'数学':'88','英语':'94','语文':'97'},
#     '影子宝':{'数学':'99','英语':'87','语文':'98'}
# }
# print(f'查询猫猫同学的语文分数：{dict2["猫猫"]["语文"]}')    #  嵌套同通过key访问对应值
# print(f'查询芬子宝同学的英语分数：{dict2["芬子宝"]["英语"]}')

# ---------------字典常用方式
# dict1 = {'姓名':'猫猫','爱好':'干饭','年龄':'20'}
# print(f"我的名字是：{dict1['姓名']}")
# dict1['姓名'] = '蔡猫猫'     # 修改key的值
# print(f'修改我的名字为蔡猫猫：{dict1["姓名"]}')
# dict1['体重'] = '47kg'    # 在字典中新增一个key：value
# print(f'新增我的体重为47kg：{dict1["体重"]}')
# print(f'我的字典为：{dict1}')
# hobbies = dict1.pop("爱好")     # 取出key对应的值，并且在字典中删除key
# print(f'取出爱好对应的值为：{hobbies}，并且在字典中删除爱好key：{dict1}')
# list1 = dict1.keys()    # 取出字典中所有的key
# print(f'取出我的字典中所有的key：{list1}')
# print(f'计算我的字典长度为：{len(dict1)}')
# dict1.clear()    # 清空字典内容
# print(f'清空我的字典内容：{dict1}')

# ------for循环字典
# for keys in dict1:
#     print(f'1字典中的key为：{keys},key对应的值为：{dict1[keys]} ')
#
# key_list = dict1.keys()
# for keys in key_list:
#     print(f'2字典中的key为：{keys},key对应的值为：{dict1[keys]} ')

# ----------------=字典小练习
# dict_eg = {
#     '猫猫':{'部门':'科技部','工资':1000,'级别':1},
#     '菜菜':{'部门':'市场部','工资':2000,'级别':2},
#     '妙妙':{'部门':'市场部','工资':3000,'级别':3},
#     '格格':{'部门':'科技部','工资':500,'级别':1},
# }
# # 通过for循环 对级别为1的员工，上升级别为2，工资加1000
# print(f'全体员工信息如下：')
# for keys in dict_eg:
#     print(f'姓名：{keys},{dict_eg[keys]}')
#
# print(f'全体员工升级信息如下：')
# for keys in dict_eg:
#     num = dict_eg[keys]['级别']
#     if num == 1:
#         dict_eg[keys]['级别'] += 1
#         dict_eg[keys]['工资'] += 1000
#     print(f'姓名：{keys},{dict_eg[keys]}')

# # ------------ 数据容器通用方法练习
# list1 = [1,5,8,9,2,3,1]    # 列表
# tuple1 = (1,5,8,9,2,3,1)    # 元组
# str1 = 'hello worth'    # 字符串
# set1 = {1,5,8,9,2,3}    # 集合
# dict1 = {'key2':1, 'key5':2, 'key1':3, 'key4':0}   #字典
#
# #  ---- max()
# print(f"输出列表中最大的元素：{max(list1)}")
# print(f"输出元组中最大的元素：{max(tuple1)}")
# print(f"输出字符串中最大的元素：{max(str1)}")
# print(f"输出集合中最大的元素：{max(set1)}")
# print(f"输出字典中最大的元素：{max(dict1)}")
# print('')
#
# #  ---- min()
# print(f"输出列表中最小的元素：{min(list1)}")
# print(f"输出元组中最小的元素：{min(tuple1)}")
# print(f"输出字符串中最小的元素：{min(str1)}")
# print(f"输出集合中最小的元素：{min(set1)}")
# print(f"输出字典中最小的元素：{min(dict1)}")
# print('')
#
# #  ---- len()
# print(f"输出列表的长度：{len(list1)}")
# print(f"输出元组的长度：{len(tuple1)}")
# print(f"输出字符串的长度：{len(str1)}")
# print(f"输出集合的长度：{len(set1)}")
# print(f"输出字典的长度：{len(dict1)}")
# print('')
#
# # ----list()
# print(f"将元组转换成列表：{list(tuple1)}")
# print(f"将字符串转换成列表：{list(str1)}")
# print(f"将集合转换成列表：{list(set1)}")
# print(f"将字典转换成列表：{list(dict1)}")
# print('')
#
# # ----tuple()
# print(f"将列表转换成元组：{tuple(list1)}")
# print(f"将字符串转换成元组：{tuple(str1)}")
# print(f"将集合转换成元组：{tuple(set1)}")
# print(f"将字典转换成元组：{tuple(dict1)}")
# print('')
#
# # ----str()
# print(f"将列表转换成字符串：{str(list1)}")
# print(f"将元组转换成字符串：{str(tuple1)}")
# print(f"将集合转换成字符串：{str(set1)}")
# print(f"将字典转换成字符串：{str(dict1)}")
# print('')
#
# # ----set()
# print(f"将列表转换成集合：{set(list1)}")
# print(f"将元组转换成集合：{set(tuple1)}")
# print(f"将字符串转换成集合：{set(str1)}")
# print(f"将字典转换成集合：{set(dict1)}")
# print('')
#
# # ----sorted(序列,reverse=True)   降序
# print(f"将列表进行降序排序：{sorted(list1,reverse=True)}")
# print(f"将元组进行降序排序：{sorted(tuple1,reverse=True)}")
# print(f"将字符串进行降序排序：{sorted(str1,reverse=True)}")
# print(f"将集合进行降序排序：{sorted(set1,reverse=True)}")
# print(f"将字典进行降序排序：{sorted(dict1,reverse=True)}")
# print('')
#
# # ----sorted(序列,reverse=True)     升序
# print(f"将列表进行降序排序：{sorted(list1,reverse=False)}")
# print(f"将元组进行降序排序：{sorted(tuple1,reverse=False)}")
# print(f"将字符串进行降序排序：{sorted(str1,reverse=False)}")
# print(f"将集合进行降序排序：{sorted(set1,reverse=False)}")
# print(f"将字典进行降序排序：{sorted(dict1,reverse=False)}")

# # -----------多个传参函数
# def fun1(x,y,z):
#     print(f'x={x},y={y},z={z}')
# # 位置传参：
# fun1(1, 2, 3)
# # 关键字传参
# fun1(1,y='maomao',z='gougou')
# fun1(1,z='maomao',y='gougou')   # kv形式可以不按照位置进行传值
#
# # 位置不定长参数
# def fun2(*args):
#     print(f'接收到的参数是：{args}')
#
# fun2(2,6,4)
#
# # 关键字不定长参数
# def fun3(**kwargs):
#     print(f'接收到的参数是：{kwargs}')
#
# fun3(name='猫猫',age=18)    # 键值对
#
# # 缺省传参
# def fun4(y,z,x=1):
#     print(f'x={x},y={y},z={z}')
#
# fun4(0,0)
#






